package com.hb.trade.server.project.util;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hb.core.pojo.project.proj.enums.BidWayEnum;
import lombok.extern.slf4j.Slf4j;
import org.fzzn.core.util.Enums;

import java.util.*;

/**
 * java bean操作工具类
 *
 * @author zhaojk
 */
@Slf4j
public class TradeBeanUtil extends BeanUtil {

    /**
     * 忽略下划线和驼峰的属性复制
     * 但属性名必须严格符合驼峰和下划线的转换格式
     * 即target的属性必须全部为下划线, source的属性必须全部为驼峰
     *
     * @deprecated BeanUtil已经实现这个逻辑了
     */
    @Deprecated
    public static void copyIgnoreFormatter(final Object target, final Object source) {
        final JSONObject item = JSONUtil.parseObj(target);
        // 复制属性
        final CopyOptions copyOptions = CopyOptions.create();
        // 下划线命名和驼峰命名的映射
        final Map<String, String> mappings = new HashMap<>();
        for (final String key : item.keySet()) {
            mappings.put(key, StrUtil.toCamelCase(key));
        }
        copyOptions.setFieldMapping(mappings);
        // 复制属性
        BeanUtil.copyProperties(target, source, copyOptions);
    }

    /**
     * 根据前端参数获取处理的项目类型
     *
     * @param bidWay 项目类型
     * @return 项目类型枚举
     * @see BidWayEnum
     */
    public static BidWayEnum parseTradeJson(final Integer bidWay) {
        if (bidWay == null) {
            log.warn("bidWay 字段不能为空");
            return null;
        }
        return Enums.of(BidWayEnum.class, bidWay);
    }

    /**
     * 根据前端参数获取处理的项目类型
     * 该方法会获取参数中的bidWay字段进行判断
     *
     * @param query 项目信息参数
     * @return 项目类型枚举
     * @see BidWayEnum
     */
    public static BidWayEnum parseTradeJson(final JSONObject query) {
        if (query == null) {
            return null;
        }
        // 项目类型, 该字段必填
        final Integer bidWay = query.getInt("bidWay");
        return parseTradeJson(bidWay);
    }

    /**
     * 将一个集合转换成tree形结构
     *
     * @param list
     * @param mappings
     * @param sortField
     * @param withAttr
     * @return TODO
     */
    public static JSONArray getTree(final List<?> list, final Map<String, String> mappings, final String sortField, final boolean withAttr) {
//        if (CollUtil.isEmpty(list)) {
//            return JSONUtil.createArray();
//        }
//        TreeBuilder<Long, ConsoleTreeEntity> treeBuilder = new TreeBuilder<>(withAttr);
//        treeBuilder.sourceOrgList(list, mappings, ConsoleTreeEntity.class);
//        treeBuilder.setSortField(sortField);
//        return treeBuilder.build();\
        return null;
    }

    /**
     * 获取一个流水号
     *
     * @return
     */
    public static String nextNo() {
        final String randomStr = RandomUtil.randomNumbers(7);
        return DateUtil.format(DateUtil.date(), "yyyyMMddHHmmssSSS") + randomStr;
    }


    /**
     * 将数据复制给目标类,忽略大小写与null,返回实例
     *
     * @param object 数据
     * @param to     目标类
     * @param <T>
     * @return
     */
    public static <T> T copy(final Object object, final Class<T> to) {
        final T t = ReflectUtil.newInstanceIfPossible(to);
        BeanUtil.copyProperties(object, t, CopyOptions.create().ignoreCase().ignoreNullValue());
        return t;
    }


    /**
     * 将集合数据复制给目标类,忽略大小写与null,返回实例集合
     *
     * @param objects 数据
     * @param to      目标类
     * @param <T>
     * @return
     */
    public static <A, T> List<T> copyList(final Collection<A> objects, final Class<T> to) {
        if (CollUtil.isEmpty(objects)) {
            return Collections.emptyList();
        }
        final List<T> list = new ArrayList<>(objects.size());
        T t;
        for (final A a : objects) {
            t = copy(a, to);
            list.add(t);
        }
        return list;
    }

}
